import java.util.Arrays;
import java.util.Locale;

public class Test {
    //字符串构造 （String是引用类型，内部并不存储字符串本身）
    public static void main1(String[] args) {
        //使用字符串常量进行赋值
        String s1 = "hello bit";
        System.out.println(s1);

        //直接new String对象
        String s2 = new String("hello bit");
        System.out.println(s2);

        //使用字符数组进行构造
        char[] array = {'h','e','l','l','o'};
        String s3 = new String(array);
        System.out.println(s3);

        //使用字节数组构造对象
        byte[] arr = {97,98,99};
        String s4 = new String(arr);
        System.out.println(s4);
    }

    //字符串内存存储（字符串常量池）
    public static void main2(String[] args) {
        //str1在进行存储的时候，"abc"会先存储到字符串常量池当中
        //当str2再次存储的时候，先会检查字符串常量池当中是否存在"abc"常量，如果存在，则不再重复存储。
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2); //输出true

        //第一次存储的时候，会将"abc"存储到常量池当中
        //每次new都会在堆中实例化新的对象。存储str2的时候，会使用常量池的"abc"对象进行存储
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s3 == s4); //输出false
    }

    // ==与equals
    public static void main3(String[] args) {
        //对于引用类型，==比较的是引用中的地址。（比较两个引用变量引用的是否为同一个对象）
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("hi");
        //s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
        System.out.println(s1 == s2); //false
        System.out.println(s1 == s3); //false

        //String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，
        //equals比较：String对象中的逐个字符
        System.out.println(s1.equals(s2)); //放置的内容相同，输出true
        System.out.println(s1.equals(s3)); //放置的内容不同，输出false
    }

    //compareTo方法
    public static void main4(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        //equals方法返回boolean类型，compareTo方法返回int类型
        //具体比较方式：
        //1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
        //2. 如果前k个字符相等（k为两个字符长度最小值），返回这两个字符串长度差值
        System.out.println(s1.compareTo(s2)); //不同 输出字符差值-1
        System.out.println(s1.compareTo(s3)); //相同 输出0
        System.out.println(s1.compareTo(s4)); //前k个字符完全相同，输出长度差值-3
    }

    //compareToIgnoreCase方法：与compareTo方式相同，但是忽略大小写比较
    public static void main5(String[] args) {
        String s1 = "ABc";
        String s2 = "abc";
        System.out.println(s1.compareToIgnoreCase(s2));//相同 输出0
    }

    //字符串查找 charAt indexOf
    public static void main6(String[] args) {
        String s = "blackpink in your area";
        System.out.println(s.charAt(10)); //i 返回指定下标的字符
        System.out.println(s.indexOf('a'));//2 返回字符第一次出现的位置
        System.out.println(s.indexOf("pink"));//5 返回字符串第一次出现的位置
        System.out.println(s.indexOf('a',5));//18 从指定位置找字符
        System.out.println(s.indexOf("in",9));//10 从指定位置找字符串
        System.out.println(s.lastIndexOf('a'));//21 从后往前找
        System.out.println(s.lastIndexOf('a',4));//2 指定一个位置从后往前找
    }

    //数字和字符串转换 valueOf parseInt
    public static void main7(String[] args) {
        //数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println("==========");
        //字符串转数字
        int data1 = Integer.parseInt("1299");
        double data2 = Double.parseDouble("12.99");
        System.out.println(data1);
        System.out.println(data2);
    }

    //大小写转换 toUpperCase toLowerCase
    public static void main8(String[] args) {
        String s1 = "Jennie";
        String s2 = "jennie";
        String s3 = "JISOO";
        System.out.println(s1.toUpperCase());//JENNIE
        System.out.println(s2.toUpperCase());//JENNIE
        System.out.println(s3.toLowerCase());//jisoo
        //这种转换是产生了新的对象，并不是修改原来的
    }

    //字符串和数组转换 toCharArray
    public static void main9(String[] args) {
        //字符串转数组
        String s = "abc";
        char[] array = s.toCharArray();
        System.out.println(Arrays.toString(array)); //[a, b, c]
        //数组转字符串
        String s2 = new String(array);
        System.out.println(s2);
    }

    //格式化 format
    public static void main10(String[] args) {
        String s = String.format("%d-%d-%d",2025,6,24);
        System.out.println(s); //2025-6-24
    }

    //字符串替换 replace
    public static void main11(String[] args) {
        String s = "ababcde";
        System.out.println(s.replace('a','z')); //zbzbcde
        System.out.println(s.replace("ab","xy")); //xyxycde
        System.out.println(s.replaceAll("ab","xy")); //xyxycde
        System.out.println(s.replaceFirst("ab","bit")); //bitabcde
        //注：由于字符串是不可变对象,替换不修改当前字符串,而是产生一个新的字符串
    }

    //字符串拆分 split
    public static void main12(String[] args) {
        String s = "hello world hello bit";
        //将字符串全部拆分
        String[] result1 = s.split(" ");
        for (String str1 : result1){
            System.out.println(str1);
        }
        System.out.println("===========");
        //按照空格分割，最多分割为2组
        String[] result2 = s.split(" ",2);
        for (String str2 : result2){
            System.out.println(str2);
        }
        System.out.println("===========");
        String str = "192\\168\\1\\1" ;
        String[] ret = str.split("\\\\");
        for (String num : ret){
            System.out.println(num);
        }
    }

    //字符串截取 substring
    public static void main13(String[] args) {
        String s = "helloworld";
        System.out.println(s.substring(5)); //world 从指定位置截取到结尾
        System.out.println(s.substring(0,5)); //hello 截取部分内容，左闭右开
    }

    //去除左右两边空格，保留中间空格 trim
    public static void main14(String[] args) {
        String s = "  hello bit ";
        System.out.println(s.trim());
    }

    //入池操作 intern
    public static void main15(String[] args) {
        char[] ch = new char[]{'a','b','c'};
        String s1 = new String(ch); //s1对象不在常量池中
        s1.intern(); //将s1对象的引用放入到常量池中（常量池没有才入池）
        String s2 = "abc"; //"abc"在常量池中存在了，s2创建时直接用常量池中"abc"的引用，所以s1s2地址相同
        System.out.println("s1地址：0x" + Integer.toHexString(System.identityHashCode(s1)));//s1地址：0x4eec7777
        System.out.println("s2地址：0x" + Integer.toHexString(System.identityHashCode(s2)));//s2地址：0x4eec7777
        System.out.println(s1 == s2); //true

       /* char[] ch = new char[]{'a','b','c'};
        String s1 = new String(ch);
        String s2 = "abc";
        System.out.println("s1地址：0x" + Integer.toHexString(System.identityHashCode(s1)));//s1地址：0x4eec7777
        System.out.println("s2地址：0x" + Integer.toHexString(System.identityHashCode(s2)));//s2地址：0x682a0b20
        System.out.println(s1 == s2); //false */
    }

}